I need to think about this more. This will conflict if someone loads both CliqueTrees and LDLFactoriztions.

Ah good point.

I'm also not very keen on adding dependencies. I wonder if we can just document this somehow. It's such a small edge-case. Very, very few people will ever need this.

We haven't released the LDL stuff yet (#2955), so we have a small window to get this right. I'll take a look.

Also takes BigFloat.

#2959

Are there situations when LDLFactorizations is preferable to CliqueTrees?

Yes: if the matrix is extremely sparse it can be ~2x faster.

Is there a better way to check if the factorisation failed other than testing Q = U' * U?

For example, your LinearAlgebra.issuccess seems wrong here:

julia> Q = [0 -1; -1 0]
2×2 Matrix{Int64}:
  0  -1
 -1   0

julia> G = LinearAlgebra.cholesky!(
           CliqueTrees.Multifrontal.ChordalCholesky(Q),
           LinearAlgebra.RowMaximum(),
       )
2×2 FChordalCholesky{:L, Float64, Int64} with 3 stored entries:
 0.0   ⋅ 
 0.0  0.0

julia> LinearAlgebra.issuccess(G)
true

julia> U = SparseArrays.sparse(G.U) * G.P
2×2 SparseArrays.SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 0.0  0.0
  ⋅   0.0

julia> U' * U
2×2 SparseArrays.SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 0.0  0.0
 0.0  0.0

LDLFactorizations halts early if it hits a zero pivot, so I think that you can just scan the diagonal.

CliqueTrees (with RowMaximum) does not halt early. However depending on the condition number etc. the factorization can be more or less accurate.

You could try solving Fx = b for some random b and compare Qx to b.

@odow

We truncate negative pivots to 0 when computing a pivoted factorization. I wasn't thinking about non-PSD matrices. I can change the behavior to something else.

So is all(iszero, G.D) sufficient to check for failure? Or I guess you might have some positive values and some negative values projected to zero so you really can tell only by comparing the matrices?

Currently, you cannot check for failure without solving a problem or reconstructing or something. However, I can push a patch tonight that sets issuccess to false if the algorithm encounters a sufficiently large negative pivot.

Also -- beware. G.D is the identity if you perform a cholesky factorization (cholesky!). It is nontrivial if you perform an LDLt factorization (ldlt!).

We just want a method that produces A = B * B' where A is PSD. Robustness is #1 priority. Sparsity is great. Performance is a lesser concern.

We just want a method that produces A = B * B' where A is PSD. Robustness is #1 priority. Sparsity is great. Performance is a lesser concern.

Right. The current status is this: CliqueTrees is robust for PSD (moreso than LDLFactorizations) but might produce strange results for non-PSD.

Your breaking example (Q = [0 -1; -1 0]) is non-PSD.